export default{
    //一维数组转树形对象
    buildTree(array, id = "id", pid = "pid", useTopNodeWhenParentNull = false) {
        //不是数组则返回
        if (!Array.isArray(array)) {
            return []
        }
        // 创建临时对象()
        let temp = {}
        // 先遍历数组，将数组的每一项添加到temp对象中
        for (let i in array) {
            //已当数组元素的id为键，当前数组元素为值
            temp[array[i][id]] = array[i]
        }

        // 创建需要返回的树形对象
        let tree = {}

        // 遍历temp对象，将当前子节点与父节点建立连接
        for (let i in temp) {
            // 当前菜单节点
            const item = temp[i]
            // 当前节点的父节点
            const itemParent = temp[item[pid]]
            // 判断当前菜单节点是否是一级菜单（父节点为0）
            // 如果是，则直接挂载到树形对象下（以id为键）
            // 如果不是，则挂载到对应的temp对象上（前提是父节点必须存在，如果不存在，则此数据属于无效数据）
            if (item[pid] === 0) {
                // 以id为键，直接挂载到树形对象下
                tree[item[id]] = item
            } else if(temp[item[pid]]){
                // 挂载到父节点的children数组中（children字段不存在的则新建）
            
                // 新建children键
                if(!itemParent.children){
                    itemParent.children = new Array()
                }
                itemParent.children.push(item)
            }else if(useTopNodeWhenParentNull){
                //强制挂载到根节点挂载到（数据异常，当前节点不存在父节点，也不是一级节点）
                tree[item[id]] = item
            }else{
                //不存在父节点，打印错误
                console.log('数据异常，当前节点不存在父节点，也不是一级节点', item)
            }
        }

        return tree
    },
    //深拷贝
    deepCopy(data){
        if(data && typeof data == 'object'){
            return JSON.parse(JSON.stringify(data))
        }else{
            return data
        }
    },
    //判断是否是空对象
    isEmptyObject(data = {}){
        const keys = Object.keys(data)
        return keys.every(key=>{
            //空值，数字0不算
            return (!data[key] && data[key] !== 0)
        })
    },
    //递归调用排序
    deepSort(arr = []){
        if(arr.length > 0){
            //对数组本身排序
            arr.sort((p1,p2)=>{
                return p2.sort - p1.sort
            })
            //递归调用排序
            arr.forEach(item=>{
                if(item.children){
                    this.deepSort(item.children)
                }
            })
        }
    }
}